<!DOCTYPE html><html><head><title>Sencha Documentation Project</title><link rel="stylesheet" href="../reset.css" type="text/css"><link rel="stylesheet" href="../prettify.css" type="text/css"><link rel="stylesheet" href="../prettify_sa.css" type="text/css"><script type="text/javascript" src="../prettify.js"></script></head><body onload="prettyPrint()"><pre class="prettyprint"><pre><span id='Ext-data.Association-method-constructor'><span id='Ext-data.Association'>/**
</span></span> * @author Ed Spencer
 * @class Ext.data.Association
 * @extends Object
 *
 * &lt;p&gt;Associations enable you to express relationships between different {@link Ext.data.Model Models}. Let's say we're
 * writing an ecommerce system where Users can make Orders - there's a relationship between these Models that we can
 * express like this:&lt;/p&gt;
 *
&lt;pre&gt;&lt;code&gt;
Ext.define('User', {
    extend: 'Ext.data.Model',
    fields: ['id', 'name', 'email'],

    hasMany: {model: 'Order', name: 'orders'}
});

Ext.define('Order', {
    extend: 'Ext.data.Model',
    fields: ['id', 'user_id', 'status', 'price'],

    belongsTo: 'User'
});
&lt;/code&gt;&lt;/pre&gt;
 *
 * &lt;p&gt;We've set up two models - User and Order - and told them about each other. You can set up as many associations on
 * each Model as you need using the two default types - {@link Ext.data.HasManyAssociation hasMany} and
 * {@link Ext.data.BelongsToAssociation belongsTo}. There's much more detail on the usage of each of those inside their
 * documentation pages. If you're not familiar with Models already, {@link Ext.data.Model there is plenty on those too}.&lt;/p&gt;
 *
 * &lt;p&gt;&lt;u&gt;Further Reading&lt;/u&gt;&lt;/p&gt;
 *
 * &lt;ul style=&quot;list-style-type: disc; padding-left: 20px;&quot;&gt;
 *   &lt;li&gt;{@link Ext.data.HasManyAssociation hasMany associations}
 *   &lt;li&gt;{@link Ext.data.BelongsToAssociation belongsTo associations}
 *   &lt;li&gt;{@link Ext.data.Model using Models}
 * &lt;/ul&gt;
 * 
 * &lt;b&gt;Self association models&lt;/b&gt;
 * &lt;p&gt;We can also have models that create parent/child associations between the same type. Below is an example, where
 * groups can be nested inside other groups:&lt;/p&gt;
 * &lt;pre&gt;&lt;code&gt;

// Server Data
{
    &quot;groups&quot;: {
        &quot;id&quot;: 10,
        &quot;parent_id&quot;: 100,
        &quot;name&quot;: &quot;Main Group&quot;,
        &quot;parent_group&quot;: {
            &quot;id&quot;: 100,
            &quot;parent_id&quot;: null,
            &quot;name&quot;: &quot;Parent Group&quot;
        },
        &quot;child_groups&quot;: [{
            &quot;id&quot;: 2,
            &quot;parent_id&quot;: 10,
            &quot;name&quot;: &quot;Child Group 1&quot;
        },{
            &quot;id&quot;: 3,
            &quot;parent_id&quot;: 10,
            &quot;name&quot;: &quot;Child Group 2&quot;
        },{
            &quot;id&quot;: 4,
            &quot;parent_id&quot;: 10,
            &quot;name&quot;: &quot;Child Group 3&quot;
        }]
    }
}

// Client code
Ext.define('Group', {
    extend: 'Ext.data.Model',
    fields: ['id', 'parent_id', 'name'],
    proxy: {
        type: 'ajax',
        url: 'data.json',
        reader: {
            type: 'json',
            root: 'groups'
        }
    },
    associations: [{
        type: 'hasMany',
        model: 'Group',
        primaryKey: 'id',
        foreignKey: 'parent_id',
        autoLoad: true,
        associationKey: 'child_groups' // read child data from child_groups
    }, {
        type: 'belongsTo',
        model: 'Group',
        primaryKey: 'id',
        foreignKey: 'parent_id',
        autoLoad: true,
        associationKey: 'parent_group' // read parent data from parent_group
    }]
});


Ext.onReady(function(){
    
    Group.load(10, {
        success: function(group){
            console.log(group.getGroup().get('name'));
            
            group.groups().each(function(rec){
                console.log(rec.get('name'));
            });
        }
    });
    
});
 * &lt;/code&gt;&lt;/pre&gt;
 *
 * @constructor
 * @param {Object} config Optional config object
 */
Ext.define('Ext.data.Association', {
<span id='Ext-data.Association-cfg-ownerModel'>    /**
</span>     * @cfg {String} ownerModel The string name of the model that owns the association. Required
     */

<span id='Ext-data.Association-cfg-associatedModel'>    /**
</span>     * @cfg {String} associatedModel The string name of the model that is being associated with. Required
     */

<span id='Ext-data.Association-cfg-primaryKey'>    /**
</span>     * @cfg {String} primaryKey The name of the primary key on the associated model. Defaults to 'id'.
     * In general this will be the {@link Ext.data.Model#idProperty} of the Model.
     */
    primaryKey: 'id',

<span id='Ext-data.Association-cfg-reader'>    /**
</span>     * @cfg {Ext.data.reader.Reader} reader A special reader to read associated data
     */
    
<span id='Ext-data.Association-cfg-associationKey'>    /**
</span>     * @cfg {String} associationKey The name of the property in the data to read the association from.
     * Defaults to the name of the associated model.
     */

    defaultReaderType: 'json',

    statics: {
        create: function(association){
            if (!association.isAssociation) {
                if (Ext.isString(association)) {
                    association = {
                        type: association
                    };
                }

                switch (association.type) {
                    case 'belongsTo':
                        return Ext.create('Ext.data.BelongsToAssociation', association);
                    case 'hasMany':
                        return Ext.create('Ext.data.HasManyAssociation', association);
                    //TODO Add this back when it's fixed
//                    case 'polymorphic':
//                        return Ext.create('Ext.data.PolymorphicAssociation', association);
                    default:
                        //&lt;debug&gt;
                        Ext.Error.raise('Unknown Association type: &quot;' + association.type + '&quot;');
                        //&lt;/debug&gt;
                }
            }
            return association;
        }
    },

    constructor: function(config) {
        Ext.apply(this, config);

        var types           = Ext.ModelManager.types,
            ownerName       = config.ownerModel,
            associatedName  = config.associatedModel,
            ownerModel      = types[ownerName],
            associatedModel = types[associatedName],
            ownerProto;

        //&lt;debug&gt;
        if (ownerModel === undefined) {
            Ext.Error.raise(&quot;The configured ownerModel was not valid (you tried &quot; + ownerName + &quot;)&quot;);
        }
        if (associatedModel === undefined) {
            Ext.Error.raise(&quot;The configured associatedModel was not valid (you tried &quot; + associatedName + &quot;)&quot;);
        }
        //&lt;/debug&gt;

        this.ownerModel = ownerModel;
        this.associatedModel = associatedModel;

<span id='Ext-data.Association-property-ownerName'>        /**
</span>         * The name of the model that 'owns' the association
         * @property ownerName
         * @type String
         */

<span id='Ext-data.Association-property-associatedName'>        /**
</span>         * The name of the model is on the other end of the association (e.g. if a User model hasMany Orders, this is 'Order')
         * @property associatedName
         * @type String
         */

        Ext.applyIf(this, {
            ownerName : ownerName,
            associatedName: associatedName
        });
    },

<span id='Ext-data.Association-method-getReader'>    /**
</span>     * Get a specialized reader for reading associated data
     * @return {Ext.data.reader.Reader} The reader, null if not supplied
     */
    getReader: function(){
        var me = this,
            reader = me.reader,
            model = me.associatedModel;

        if (reader) {
            if (Ext.isString(reader)) {
                reader = {
                    type: reader
                };
            }
            if (reader.isReader) {
                reader.setModel(model);
            } else {
                Ext.applyIf(reader, {
                    model: model,
                    type : me.defaultReaderType
                });
            }
            me.reader = Ext.createByAlias('reader.' + reader.type, reader);
        }
        return me.reader || null;
    }
});
</pre></pre></body></html>